package com.AdvancedDemos.LearnThread多线程;

public class Thread类常用方法 {
    public static void main(String[] args) throws InterruptedException {
        /**
         * Thread提供了很多与线程操作相关的方法
         * public void run() --- 线程的任务方法
         * public void start() --- 启动线程
         * public string getName() --- 获取当前线程的名称，线程名称默认是Thread-索引
         * public void setName(String name) --- 为线程设置名称
         * public static Thread currentThread() --- 获取当前执行的线程对象
         * public static void sleep(long time) --- 让当前执行的线程休眠多少毫秒后，再继续执行
         * public final void join()... --- 让调用当前这个方法的线程先执行完!
         * public final void setPriority(int newPriority) --- 在start前调用,给进程设置优先级,1~10,默认是5,1最低,10最高,优先级越高越可能抢到CPU
         *
         * public Thread( String name) --- 可以为当前线程指定名称
         * public Thread(Runnable target) --- 封装Runnable对象成为线程对象
         * public Thread(Runnable target，string name) --- 封装Runnable对象成为线程对象，并指定线程名称
         */

        ExampleThread t1 = new ExampleThread("一号线程");//调用Thread有参构造函数直接给线程指定名字,无序后期再setName
        ExampleThread t2 = new ExampleThread();

//        t1.setName("一号线程");//给线程起名字应当在线程启动之前
        t1.start();
        System.out.println(t1.getName());//Thread-0  一号线程
        t2.setName("二号线程");
        t2.start();
        System.out.println(t2.getName());//Thread-1  二号线程

        Thread mainThread = Thread.currentThread();//哪个线程执行本句,就会拿到哪个线程对象
        mainThread.setName("最牛的线程");
        System.out.println(mainThread.getName());//main  主线程对象的名字  最牛的线程


        for (int i = 0; i < 3; i++) {
            System.out.println(mainThread.getName() + "线程输出:" + i);
        }

        //Thread-0
        //Thread-1
        //main
        //主线程输出:0
        //主线程输出:1
        //主线程输出:2
        //子线程Thread-1输出:0
        //子线程Thread-0输出:0
        //子线程Thread-1输出:1
        //子线程Thread-0输出:1
        //子线程Thread-1输出:2
        //子线程Thread-0输出:2

        //一号线程
        //二号线程
        //最牛的线程
        //最牛的线程线程输出:0
        //最牛的线程线程输出:1
        //最牛的线程线程输出:2
        //子线程二号线程输出:0
        //子线程二号线程输出:1
        //子线程二号线程输出:2
        //子线程一号线程输出:0
        //子线程一号线程输出:1
        //子线程一号线程输出:2


        /**
         * 掌握sleep方法,join方法的作用
         */

        //演示sleep方法
        for (int i = 0; i < 5; i++) {
            System.out.println("---------------");
            if (i == 3) {//i==3时休眠5s
                Thread.sleep(5000);//当前执行的线程暂停5s(5000ms)再继续执行
            }
            System.out.println("i = " + i);
            //i = 0
            //i = 1
            //i = 2
            //此处休眠了5s
            //i = 3
            //i = 4
        }

        System.out.println("---------------");
        //演示join方法
        //join方法的作用:让当前调用这个方法的线程先执行完
        ExampleThread e1 = new ExampleThread("1号线程");
        e1.start();
        e1.join();//线程e1执行完毕后才会执行后面的其他线程

        ExampleThread e2 = new ExampleThread("2号线程");
        e2.start();
        e2.join();

        ExampleThread e3 = new ExampleThread("3号线程");
        e3.start();
        e3.join();

        //子线程1号线程输出:0
        //子线程1号线程输出:1
        //子线程1号线程输出:2
        //子线程2号线程输出:0
        //子线程2号线程输出:1
        //子线程2号线程输出:2
        //子线程3号线程输出:0
        //子线程3号线程输出:1
        //子线程3号线程输出:2
    }
}

class ExampleThread extends Thread {
    /**
     * 重写父类带参构造,用于在创建线程时指定线程名称
     *
     * @param name
     */
    public ExampleThread(String name) {
        super(name);//为当前线程设置名字
    }

    public ExampleThread() {
    }

    @Override
    public void run() {
        Thread thread = Thread.currentThread();//哪个线程执行本句,就会拿到哪个线程对象
        for (int i = 0; i < 3; i++) {
            System.out.println("子线程" + thread.getName() + "输出:" + i);
        }
    }
}
